home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 January: Mac OS SDK / Dev.CD Jan 96 SDK / Dev.CD Jan 96 SDK1.toast / Development Kits (Disc 1) / AOCE / Development Tools / Interfaces / PInterfaces / OCE.p < prev    next >
Encoding:
Text File  |  1993-11-10  |  46.8 KB  |  1,605 lines  |  [TEXT/MPS ]
  1. {***********************************************************
  2.  
  3. Created: Monday, November 8, 1993 11:28 AM
  4.  OCE.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.   Copyright Apple Computer, Inc. 1990-1993
  8.   All rights reserved
  9.  
  10. ***********************************************************}
  11.  
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes:= 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.     UNIT OCE;
  19.     INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED UsingOCE}
  23. {$SETC UsingOCE:= 1}
  24.  
  25. {$I+}
  26. {$SETC OCEIncludes:= UsingIncludes}
  27. {$SETC UsingIncludes:= 1}
  28.  
  29.  
  30.  
  31. {$IFC UNDEFINED UsingAliases}
  32. {$I $$Shell(PInterfaces)Aliases.p}        { for AliasPtr }
  33. {$ENDC}
  34.  
  35. {$IFC UNDEFINED UsingAppleEvents}
  36. {$I $$Shell(PInterfaces)AppleEvents.p}    { for DescType }
  37. {$ENDC}
  38.  
  39. {$IFC UNDEFINED UsingScript}
  40. {$I $$Shell(PInterfaces)Script.p}        { for smRoman }
  41. {$ENDC}
  42.  
  43. {$IFC UNDEFINED UsingTypes}
  44. {$I $$Shell(PInterfaces)Types.p}
  45. {$ENDC}
  46.  
  47. {$SETC UsingIncludes:= OCEIncludes}
  48.  
  49.  
  50. {
  51. All utility routines defined here are callable at interrupt level.  Currently,
  52. this is done at the expense of not using the international utilities package
  53. for STRING comparisons (we just use the ROM-based RelString trap).
  54. }
  55.  
  56.  
  57. {
  58. Defines for the trap selector values.
  59.  
  60. Note:  Some selector values also chosen from this same range of numbers appear
  61. in the file OCEMessaging.h.  Check there before you add a new value.
  62. }
  63.  
  64. CONST
  65. kOCECopyCreationID                    = 768;
  66. kOCECopyDirDiscriminator            = 769;
  67. kOCECopyLocalRecordID                = 770;
  68. kOCECopyPackedDSSpec                = 771;
  69. kOCECopyPackedPathName                = 772;
  70. kOCECopyPackedRLI                    = 773;
  71. kOCECopyPackedRecordID                = 774;
  72. kOCECopyRLI                            = 775;
  73. kOCECopyRString                        = 776;
  74. kOCECopyRecordID                    = 777;
  75. kOCECopyShortRecordID                = 778;
  76. kOCEDuplicateRLI                    = 779;
  77. kOCEEqualCreationID                    = 780;
  78. kOCEEqualDirDiscriminator            = 781;
  79. kOCEEqualDSSpec                        = 782;
  80. kOCEEqualLocalRecordID                = 783;
  81. kOCEEqualPackedDSSpec                = 784;
  82. kOCEEqualPackedPathName                = 785;
  83. kOCEEqualPackedRecordID                = 786;
  84. kOCEEqualPackedRLI                    = 787;
  85. kOCEEqualRecordID                    = 788;
  86. kOCEEqualRLI                        = 789;
  87. kOCEEqualRString                    = 790;
  88. kOCEEqualShortRecordID                = 791;
  89. kOCEExtractAlias                    = 792;
  90. kOCEGetDSSpecInfo                    = 793;
  91. kOCEGetIndAttributeType                = 794;
  92. kOCEGetIndRecordType                = 795;
  93. kOCEGetXtnType                        = 796;
  94. kOCEIsNullPackedPathName            = 797;
  95. kOCENewLocalRecordID                = 798;
  96. kOCENewRLI                            = 799;
  97. kOCENewRecordID                        = 800;
  98. kOCENewShortRecordID                = 801;
  99. kOCEPackDSSpec                        = 802;
  100. kOCEPackPathName                    = 803;
  101. kOCEPackRLI                            = 804;
  102. kOCEPackRLIParts                    = 805;
  103. kOCEPackRecordID                    = 806;
  104. kOCEPackedDSSpecSize                = 807;
  105. kOCEPackedPathNameSize                = 808;
  106. kOCEPackedRLIPartsSize                = 809;
  107. kOCEPackedRLISize                    = 810;
  108. kOCEPackedRecordIDSize                = 811;
  109. kOCEDNodeNameCount                    = 812;
  110. kOCERelRString                        = 813;
  111. kOCESetCreationIDtoNull                = 814;
  112. kOCEUnpackDSSpec                    = 815;
  113. kOCEUnpackPathName                    = 816;
  114. kOCEUnpackRLI                        = 817;
  115. kOCEUnpackRecordID                    = 818;
  116. kOCEValidPackedDSSpec                = 819;
  117. kOCEValidPackedPathName                = 820;
  118. kOCEValidPackedRecordID                = 821;
  119. kOCEValidPackedRLI                    = 822;
  120. kOCEValidRLI                        = 823;
  121. kOCEValidRString                    = 824;
  122. kOCECToRString                        = 825;
  123. kOCEPToRString                        = 826;
  124. kOCERToPString                        = 827;
  125. kOCEPathFinderCID                    = 828;
  126. kOCEStreamPackedDSSpec                = 829;
  127.  
  128. kOCENullCID                            = 836;
  129. kOCEGetAccessControlDSSpec            = 837;
  130. kOCEGetRootPackedRLI                = 838;
  131.  
  132.  
  133.  
  134.  
  135. TYPE
  136. OCERecordTypeIndex = INTEGER;
  137. OCEAttributeTypeIndex = INTEGER;
  138.  
  139.  
  140. {
  141. All these standard definitions begin with the Apple symbol (not shown here).
  142.  
  143. NOTE:  To access these, you must call OCEGetIndRecordType or OCEGetIndAttributeType
  144. with the proper index.  These routines return pointers to the standard type.
  145. This was done so that code fragments (INITs, CDEVs, DSAMs, etc). which cannot
  146. use global data can also use these.
  147. }
  148.  
  149. { Indices for the standard definitions for certain record types (OCERecordTypeIndex): }
  150.  
  151. CONST
  152. kUserRecTypeNum             = 1;        { "User" }
  153. kGroupRecTypeNum            = 2;        { "Group" }
  154. kMnMRecTypeNum                = 3;        { "AppleMail™ M&M" }
  155. kMnMForwarderRecTypeNum        = 4;        { "AppleMail™ Fwdr" }
  156. kNetworkSpecRecTypeNum        = 5;        { "NetworkSpec" }
  157. kADAPServerRecTypeNum        = 6;        { "ADAP Server" }
  158. kADAPDNodeRecTypeNum        = 7;        { "ADAP DNode" }
  159. kADAPDNodeRepRecTypeNum        = 8;        { "ADAP DNode Rep" }
  160. kServerSetupRecTypeNum        = 9;        { "Server Setup" }
  161. kDirectoryRecTypeNum        = 10;        { "Directory" }
  162. kDNodeRecTypeNum            = 11;        { "DNode" }
  163. kSetupRecTypeNum            = 12;        { "Setup" }
  164. kMSAMRecTypeNum                = 13;        { "MSAM" }
  165. kDSAMRecTypeNum                = 14;        { "DSAM" }
  166. kAttributeValueRecTypeNum    = 15;        { "Attribute Value" }
  167. kBusinessCardRecTypeNum        = 16;        { "Business Card" }
  168. kMailServiceRecTypeNum        = 17;        { "Mail Service" }
  169. kCombinedRecTypeNum            = 18;        { "Combined" }
  170. kOtherServiceRecTypeNum        = 19;        { "Other Service" }
  171. kAFPServiceRecTypeNum        = 20;        { "Other Service afps" }
  172.  
  173. kFirstOCERecTypeNum    = kUserRecTypeNum;            { first standard OCE record type }
  174. kLastOCERecTypeNum    = kAFPServiceRecTypeNum;    { last standard OCE record type }
  175. kNumOCERecTypes        = (kLastOCERecTypeNum - kFirstOCERecTypeNum + 1);
  176.  
  177.  
  178. { Indices for the standard definitions for certain attribute types (OCEAttributeTypeIndex): }
  179.  
  180. kMemberAttrTypeNum                = 1001;        { "Member" }
  181. kAdminsAttrTypeNum                = 1002;        { "Administrators" }
  182. kMailSlotsAttrTypeNum            = 1003;        { "mailslots" }
  183. kPrefMailAttrTypeNum            = 1004;        { "pref mailslot" }
  184. kAddressAttrTypeNum                = 1005;        { "Address" }
  185. kPictureAttrTypeNum                = 1006;        { "Picture" }
  186. kAuthKeyAttrTypeNum                = 1007;        { "auth key" }
  187. kTelephoneAttrTypeNum            = 1008;        { "Telephone" }
  188. kNBPNameAttrTypeNum                = 1009;        { "NBP Name" }
  189. kQMappingAttrTypeNum            = 1010;        { "ForwarderQMap" }
  190. kDialupSlotAttrTypeNum            = 1011;        { "DialupSlotInfo" }
  191. kHomeNetAttrTypeNum                = 1012;        { "Home Internet" }
  192. kCoResAttrTypeNum                = 1013;        { "Co-resident M&M" }
  193. kFwdrLocalAttrTypeNum            = 1014;        { "FwdrLocalRecord" }
  194. kConnectAttrTypeNum                = 1015;        { "Connected To" }
  195. kForeignAttrTypeNum                = 1016;        { "Foreign RLIs" }
  196. kOwnersAttrTypeNum                = 1017;        { "Owners" }
  197. kReadListAttrTypeNum            = 1018;        { "ReadList" }
  198. kWriteListAttrTypeNum            = 1019;        { "WriteList" }
  199. kDescriptorAttrTypeNum            = 1020;        { "Descriptor" }
  200. kCertificateAttrTypeNum            = 1021;        { "Certificate" }
  201. kMsgQsAttrTypeNum                = 1022;        { "MessageQs" }
  202. kPrefMsgQAttrTypeNum            = 1023;        { "PrefMessageQ" }
  203. kMasterPFAttrTypeNum            = 1024;        { "MasterPF" }
  204. kMasterNetSpecAttrTypeNum        = 1025;        { "MasterNetSpec" }
  205. kServersOfAttrTypeNum            = 1026;        { "Servers Of" }
  206. kParentCIDAttrTypeNum            = 1027;        { "Parent CID" }
  207. kNetworkSpecAttrTypeNum            = 1028;        { "NetworkSpec" }
  208. kLocationAttrTypeNum            = 1029;        { "Location" }
  209. kTimeSvrTypeAttrTypeNum            = 1030;        { "TimeServer Type" }
  210. kUpdateTimerAttrTypeNum            = 1031;        { "Update Timer" }
  211. kShadowsOfAttrTypeNum            = 1032;        { "Shadows Of" }
  212. kShadowServerAttrTypeNum        = 1033;        { "Shadow Server" }
  213. kTBSetupAttrTypeNum                = 1034;        { "TB Setup" }
  214. kMailSetupAttrTypeNum            = 1035;        { "Mail Setup" }
  215. kSlotIDAttrTypeNum                = 1036;        { "SlotID" }
  216. kGatewayFileIDAttrTypeNum        = 1037;        { "Gateway FileID" }
  217. kMailServiceAttrTypeNum            = 1038;        { "Mail Service" }
  218. kStdSlotInfoAttrTypeNum            = 1039;        { "Std Slot Info" }
  219. kAssoDirectoryAttrTypeNum        = 1040;        { "Asso. Directory" }
  220. kDirectoryAttrTypeNum            = 1041;        { "Directory" }
  221. kDirectoriesAttrTypeNum            = 1042;        { "Directories" }
  222. kSFlagsAttrTypeNum                = 1043;        { "SFlags" }
  223. kLocalNameAttrTypeNum            = 1044;        { "Local Name" }
  224. kLocalKeyAttrTypeNum            = 1045;        { "Local Key" }
  225. kDirUserRIDAttrTypeNum            = 1046;        { "Dir User RID" }
  226. kDirUserKeyAttrTypeNum            = 1047;        { "Dir User Key" }
  227. kDirNativeNameAttrTypeNum        = 1048;        { "Dir Native Name" }
  228. kCommentAttrTypeNum                = 1049;        { "Comment" }
  229. kRealNameAttrTypeNum            = 1050;        { "Real Name" }
  230. kPrivateDataAttrTypeNum            = 1051;        { "Private Data" }
  231. kDirTypeAttrTypeNum                = 1052;        { "Directory Type" }
  232. kDSAMFileAliasAttrTypeNum        = 1053;        { "DSAM File Alias" }
  233. kCanAddressToAttrTypeNum        = 1054;        { "Can Address To" }
  234. kDiscriminatorAttrTypeNum        = 1055;        { "Discriminator" }
  235. kAliasAttrTypeNum                = 1056;        { "Alias" }
  236. kParentMSAMAttrTypeNum            = 1057;        { "Parent MSAM" }
  237. kParentDSAMAttrTypeNum            = 1058;        { "Parent DSAM" }
  238. kSlotAttrTypeNum                = 1059;        { "Slot" }
  239. kAssoMailServiceAttrTypeNum        = 1060;        { "Asso. Mail Service" }
  240. kFakeAttrTypeNum                = 1061;        { "Fake" }
  241. kInheritSysAdminAttrTypeNum        = 1062;        { "Inherit SysAdministrators" }
  242. kPreferredPDAttrTypeNum            = 1063;        { "Preferred PD" }
  243. kLastLoginAttrTypeNum            = 1064;        { "Last Login" }
  244. kMailerAOMStateAttrTypeNum        = 1065;        { "Mailer AOM State" }
  245. kMailerSendOptionsAttrTypeNum    = 1066;        { "Mailer Send Options" }
  246. kJoinedAttrTypeNum                = 1067;        { "Joined" }
  247. kUnconfiguredAttrTypeNum        = 1068;        { "Unconfigured" }
  248. kVersionAttrTypeNum                = 1069;        { "Version" }
  249. kLocationNamesAttrTypeNum        = 1070;        { "Location Names" }
  250. kActiveAttrTypeNum                = 1071;        { "Active" }
  251. kDeleteRequestedAttrTypeNum        = 1072;        { "Delete Requested" }
  252. kGatewayTypeAttrTypeNum            = 1073;        { "Gateway Type" }
  253.  
  254. kFirstOCEAttrTypeNum    = kMemberAttrTypeNum;        { first standard OCE attr type }
  255. kLastOCEAttrTypeNum        = kGatewayTypeAttrTypeNum;    { last standard OCE attr type }
  256. kNumOCEAttrTypes        = (kLastOCEAttrTypeNum - kFirstOCEAttrTypeNum + 1);
  257.  
  258.  
  259. { For anyone who absolutely needs a define of the body of the standard record or
  260. attribute type, use these below.  CAUTION!  All the types below are assumed to be
  261. in character set 'smRoman'.  If you try to compare these to some RString or
  262. AttributeType variable, you must take the character set code into account.  Future
  263. standard types may be defined using character sets other than 'smRoman'.  The
  264. first character of each of these is $F0, the Apple symbol.
  265. }
  266.  
  267. { Standard definitions for certain record types: }
  268.  
  269. kUserRecTypeBody             = 'aoce User';
  270. kGroupRecTypeBody            = 'aoce Group';
  271. kMnMRecTypeBody                = 'aoce AppleMail™ M&M';
  272. kMnMForwarderRecTypeBody    = 'aoce AppleMail™ Fwdr';
  273. kNetworkSpecRecTypeBody        = 'aoce NetworkSpec';
  274. kADAPServerRecTypeBody        = 'aoce ADAP Server';
  275. kADAPDNodeRecTypeBody        = 'aoce ADAP DNode';
  276. kADAPDNodeRepRecTypeBody    = 'aoce ADAP DNode Rep';
  277. kServerSetupRecTypeBody        = 'aoce Server Setup';
  278. kDirectoryRecTypeBody        = 'aoce Directory';
  279. kDNodeRecTypeBody            = 'aoce DNode';
  280. kSetupRecTypeBody            = 'aoce Setup';
  281. kMSAMRecTypeBody            = 'aoce MSAM';
  282. kDSAMRecTypeBody            = 'aoce DSAM';
  283. kAttributeValueRecTypeBody    = 'aoce Attribute Value';
  284. kBusinessCardRecTypeBody    = 'aoce Business Card';
  285. kMailServiceRecTypeBody        = 'aoce Mail Service';
  286. kCombinedRecTypeBody        = 'aoce Combined';
  287. kOtherServiceRecTypeBody    = 'aoce Other Service';
  288. kAFPServiceRecTypeBody        = 'aoce Other Service afps';
  289.  
  290. { Standard definitions for certain attribute types: }
  291.  
  292. kMemberAttrTypeBody                = 'aoce Member';
  293. kAdminsAttrTypeBody                = 'aoce Administrators';
  294. kMailSlotsAttrTypeBody            = 'aoce mailslots';
  295. kPrefMailAttrTypeBody            = 'aoce pref mailslot';
  296. kAddressAttrTypeBody            = 'aoce Address';
  297. kPictureAttrTypeBody            = 'aoce Picture';
  298. kAuthKeyAttrTypeBody            = 'aoce auth key';
  299. kTelephoneAttrTypeBody            = 'aoce Telephone';
  300. kNBPNameAttrTypeBody            = 'aoce NBP Name';
  301. kQMappingAttrTypeBody            = 'aoce ForwarderQMap';
  302. kDialupSlotAttrTypeBody            = 'aoce DialupSlotInfo';
  303. kHomeNetAttrTypeBody            = 'aoce Home Internet';
  304. kCoResAttrTypeBody                = 'aoce Co-resident M&M';
  305. kFwdrLocalAttrTypeBody            = 'aoce FwdrLocalRecord';
  306. kConnectAttrTypeBody            = 'aoce Connected To';
  307. kForeignAttrTypeBody            = 'aoce Foreign RLIs';
  308. kOwnersAttrTypeBody                = 'aoce Owners';
  309. kReadListAttrTypeBody            = 'aoce ReadList';
  310. kWriteListAttrTypeBody            = 'aoce WriteList';
  311. kDescriptorAttrTypeBody            = 'aoce Descriptor';
  312. kCertificateAttrTypeBody        = 'aoce Certificate';
  313. kMsgQsAttrTypeBody                = 'aoce MessageQs';
  314. kPrefMsgQAttrTypeBody            = 'aoce PrefMessageQ';
  315. kMasterPFAttrTypeBody            = 'aoce MasterPF';
  316. kMasterNetSpecAttrTypeBody        = 'aoce MasterNetSpec';
  317. kServersOfAttrTypeBody            = 'aoce Servers Of';
  318. kParentCIDAttrTypeBody            = 'aoce Parent CID';
  319. kNetworkSpecAttrTypeBody        = 'aoce NetworkSpec';
  320. kLocationAttrTypeBody            = 'aoce Location';
  321. kTimeSvrTypeAttrTypeBody        = 'aoce TimeServer Type';
  322. kUpdateTimerAttrTypeBody        = 'aoce Update Timer';
  323. kShadowsOfAttrTypeBody            = 'aoce Shadows Of';
  324. kShadowServerAttrTypeBody        = 'aoce Shadow Server';
  325. kTBSetupAttrTypeBody            = 'aoce TB Setup';
  326. kMailSetupAttrTypeBody            = 'aoce Mail Setup';
  327. kSlotIDAttrTypeBody                = 'aoce SlotID';
  328. kGatewayFileIDAttrTypeBody        = 'aoce Gateway FileID';
  329. kMailServiceAttrTypeBody        = 'aoce Mail Service';
  330. kStdSlotInfoAttrTypeBody        = 'aoce Std Slot Info';
  331. kAssoDirectoryAttrTypeBody        = 'aoce Asso. Directory';
  332. kDirectoryAttrTypeBody            = 'aoce Directory';
  333. kDirectoriesAttrTypeBody        = 'aoce Directories';
  334. kSFlagsAttrTypeBody                = 'aoce SFlags';
  335. kLocalNameAttrTypeBody            = 'aoce Local Name';
  336. kLocalKeyAttrTypeBody            = 'aoce Local Key';
  337. kDirUserRIDAttrTypeBody            = 'aoce Dir User RID';
  338. kDirUserKeyAttrTypeBody            = 'aoce Dir User Key';
  339. kDirNativeNameAttrTypeBody        = 'aoce Dir Native Name';
  340. kCommentAttrTypeBody            = 'aoce Comment';
  341. kRealNameAttrTypeBody            = 'aoce Real Name';
  342. kPrivateDataAttrTypeBody        = 'aoce Private Data';
  343. kDirTypeAttrTypeBody            = 'aoce Directory Type';
  344. kDSAMFileAliasAttrTypeBody        = 'aoce DSAM File Alias';
  345. kCanAddressToAttrTypeBody        = 'aoce Can Address To';
  346. kDiscriminatorAttrTypeBody        = 'aoce Discriminator';
  347. kAliasAttrTypeBody                = 'aoce Alias';
  348. kParentMSAMAttrTypeBody            = 'aoce Parent MSAM';
  349. kParentDSAMAttrTypeBody            = 'aoce Parent DSAM';
  350. kSlotAttrTypeBody                = 'aoce Slot';
  351. kAssoMailServiceAttrTypeBody     = 'aoce Asso. Mail Service';
  352. kFakeAttrTypeBody                = 'aoce Fake';
  353. kInheritSysAdminAttrTypeBody     = 'aoce Inherit SysAdministrators';
  354. kPreferredPDAttrTypeBody        = 'aoce Preferred PD';
  355. kLastLoginAttrTypeBody            = 'aoce Last Login';
  356. kMailerAOMStateAttrTypeBody        = 'aoce Mailer AOM State';
  357. kMailerSendOptionsAttrTypeBody    = 'aoce Mailer Send Options';
  358. kJoinedAttrTypeBody                = 'aoce Joined';
  359. kUnconfiguredAttrTypeBody        = 'aoce Unconfigured';
  360. kVersionAttrTypeBody            = 'aoce Version';
  361. kLocationNamesAttrTypeBody        = 'aoce Location Names';
  362. kActiveAttrTypeBody                = 'aoce Active';
  363. kDeleteRequestedAttrTypeBody    = 'aoce Delete Requested';
  364. kGatewayTypeAttrTypeBody         = 'aoce Gateway Type';
  365.  
  366.  
  367.  
  368. { Miscellaneous enums: }
  369.  
  370. kRString32Size            = 32;            { max size of the body field in RString32 }
  371. kRString64Size            = 64;            { max size of the body field in RString64 }
  372. kNetworkSpecMaxBytes    = 32;            { max size of the body field in NetworkSpec }
  373. kPathNameMaxBytes        = 1024;            { max size of the data field in PackedPathName }
  374. kDirectoryNameMaxBytes    = 32;            { max size of the body field in DirectoryName }
  375. kAttributeTypeMaxBytes    = 32;            { max size of the body field in AttributeType }
  376. kAttrValueMaxBytes        = 65536;        { max size of any attribute value }
  377. kRStringMaxBytes        = 256;            { max size (bytes: in) of the body field of a recordName or recordType }
  378. kRStringMaxChars        = 128;            { max size (chars: in) of the body field of a recordName or recordType }
  379.  
  380.  
  381.  
  382. kNULLDNodeNumber = 0;                    { Special value meaning none specified }
  383. kRootDNodeNumber = 2;                    { DNodeNum corresponding to the root of the tree }
  384.  
  385.  
  386.  
  387.  
  388. {
  389. This enum is used to select the kind of RString in calls such as OCERelRString,
  390. OCEEqualRString, and OCEValidRString.
  391.  
  392. eGenericSensitive and eGenericInsensitive are enumerators that can be used if you
  393. use RStrings for things other than what you see in this file.  If you want them to
  394. be compared in a case- and diacritical-sensitive manner (c ≠ C ≠ ç), use
  395. eGenericSensitive.  If you want them to be compared in a case- and diacritical-
  396. insensitive manner (c = C = ç), use eGenericInensitive.
  397. WARNING:  do not use eGenericSensitive and eGenericInsensitive with directory
  398. names, entity names, pathname parts, entity types, network specs, or attribute
  399. types!  Don't assume that you know how they should be compared!!!
  400. }
  401.  
  402. { values of RStringKind }
  403. CONST
  404. kOCEDirName                        = 0;
  405. kOCERecordOrDNodeName            = 1;
  406. kOCERecordType                    = 2;
  407. kOCENetworkSpec                    = 3;
  408. kOCEAttrType                    = 4;
  409. kOCEGenericSensitive            = 5;
  410. kOCEGenericInsensitive            = 6;
  411.  
  412. TYPE
  413. RStringKind = INTEGER;
  414.  
  415.  
  416. { Values for the signature field in Discriminator }
  417.  
  418. { values of OCEDirectoryKind }
  419. CONST
  420. kDirAllKinds                = 0;
  421. kDirADAPKind                = 'adap';
  422. kDirPersonalDirectoryKind    = 'pdir';
  423. kDirDSAMKind                = 'dsam';
  424.  
  425. TYPE
  426. OCEDirectoryKind = LONGINT;
  427.  
  428.  
  429. { Values returned by GetDSSpecInfo() }
  430. CONST
  431. kOCEInvalidDSSpec    = '????';            { could not be determined }
  432. kOCEDirsRootDSSpec    = 'root';            { root of all catalogs ("Catalogs" icon) }
  433. kOCEDirectoryDSSpec    = 'dire';            { catalog }
  434. kOCEDNodeDSSpec        = 'dnod';            { d-node }
  435. kOCERecordDSSpec    = 'reco';            { record }
  436. kOCEentnDSSpec        = 'entn';            { extensionType is 'entn' }
  437. kOCENOTentnDSSpec    = 'not ';            { extensionType is not 'entn' }
  438.  
  439.  
  440.  
  441.  
  442. { Values for AttributeTag }
  443. typeRString            = 'rstr';
  444. typePackedDSSpec    = 'dspc';
  445. typeBinary            = 'bnry';
  446.  
  447.  
  448.  
  449.  
  450. {
  451. Bit flag corresponding to the isCluster bit.  Use it like this:
  452.     if (foo & kCanContainRecordsBit)
  453.         then this is a cluster!
  454. kForeignNode is used to indicate nodes in the name hierarchy that correspond to
  455. foreign directories (meaning ADAP sees no clusters or DNodes beneath it, but
  456. mail routers might be able to route to clusters beneath it.
  457. }
  458.  
  459. kCanContainRecordsBit = 0;
  460. kForeignNodeBit = 1;
  461.  
  462. { values of DirNodeKind }
  463. kCanContainRecords    = $00000001;  {1<<kCanContainRecordsBit}
  464. kForeignNode        = $00000002;  {1<<kForeignNodeBit}
  465.  
  466. TYPE
  467. DirNodeKind = LONGINT;
  468.  
  469.  
  470.  
  471.  
  472. {*** Toolbox Control ***}
  473.  
  474. {
  475. We will have a version number and attributes for toolboxes off the aa5e trap
  476. and the S&F server trap.
  477.  
  478. This includes the OCE toolbox and S&F Server.  [Note: the S&F server will
  479. change to ONLY service ServerGateway calls —it will then be necessary to run
  480. it co–resident with an OCE toolbox].
  481.  
  482. The high order word will represent the S&F Server version number.  The low
  483. order word will represent the OCE toolbox version number.  These will be zero
  484. until the component is up and running.  It is not possible to know these
  485. a–priori. Note: there will not be a seperate version numbers for each component
  486. in the OCE toolbox or S&F server.
  487.  
  488. The above is consistent with the standard System 7.0 usage of Gestalt.
  489.  
  490. The oce tb attribute gestaltOCETBPresent implies the existence of OCE on a
  491. machine.
  492.  
  493. The OCE TB attribute gestaltOCETBAvailable implies the availablity of OCE calls.
  494.  
  495. The attribute gestaltOCESFServerAvailable implies the availablity of OCE calls
  496. available through the S&F server. This are essentially the server gateway calls.
  497.  
  498. Any (future) remaining OCE attributes may not be established correctly until
  499. the attribute gestaltOCETBAvailable is set.
  500.  
  501. The gestalt selectors and values are listed below:
  502. }
  503.  
  504. CONST
  505. gestaltOCEToolboxVersion    = 'ocet';    { OCE Toolbox version }
  506. gestaltOCEToolboxAttr        = 'oceu';    { OCE Toolbox attributes }
  507.  
  508.  
  509.  
  510. { version includes:
  511.  *  dirtb
  512.  *  authtb
  513.  *  mailtb
  514.  *  ipmtb
  515.  *  personal directory
  516.  *  ADSPSecure
  517.  * e.g. all interfaces dependent on the aa5e trap.
  518. }
  519. gestaltOCETB                = $0100;    { OCE Toolbox version 1.0 }
  520. gestaltSFServer                = $0100;    { S&F Server version 1.0 }
  521. gestaltOCETBPresent            = $1;        { OCE toolbox is present, not running }
  522. gestaltOCETBAvailable        = $2;        { OCE toolbox is running and available }
  523. gestaltOCESFServerAvailable    = $4;        { S&F Server is running and available }
  524.  
  525.  
  526. {    Constants used for Transitions. }
  527.  
  528. ATTransIPMStart        = 'ipms';
  529. ATTransIPMShutdown    = 'ipmd';
  530. ATTransDirStart        = 'dirs';
  531. ATTransDirShutdown    = 'dird';
  532. ATTransAuthStart    = 'auts';
  533. ATTransAuthShutdown    = 'autd';
  534. ATTransSFStart        = 's&fs';
  535. ATTransSFShutdown    = 's&fd';
  536.  
  537.  
  538.  
  539.  
  540.  
  541. { Some definitions for time-related parameters: }
  542.  
  543. TYPE
  544. UTCTime = LONGINT;                        { Interpreted as UTC seconds since 1/1/1904 }
  545. UTCOffset = LONGINT;                    { seconds EAST of Greenwich }
  546.  
  547.  
  548. CharacterSet = INTEGER;                    { This is the same as the ScriptManager script. }
  549.  
  550.  
  551. {*** RString ***}
  552.  
  553.  
  554. {
  555. struct RString is a maximum-sized structure.  Allocate one of these and it will
  556. hold any valid RString.
  557. }
  558.  
  559. RStringHeader = RECORD
  560.     charSet: CharacterSet;
  561.     dataLength: INTEGER;
  562.     END;
  563.  
  564. RString = RECORD
  565.     charSet: CharacterSet;
  566.     dataLength: INTEGER;
  567.  
  568.     body: PACKED ARRAY[1..kRStringMaxBytes] OF Byte;        { place for characters }
  569.     END;
  570.  
  571.  
  572. { struct ProtoRString is a minimum-sized structure.  Use this for a variable-length
  573. RString. }
  574.  
  575. ProtoRString = RECORD                    { proto-RString used for variable length rStrings }
  576.     charSet: CharacterSet;
  577.     dataLength: INTEGER;
  578.  
  579.     { Followed by body }
  580.     END;
  581.  
  582. RStringPtr = ^RString;
  583. RStringHandle = ^RStringPtr;
  584. ProtoRStringPtr = ^ProtoRString;
  585.  
  586. CONST
  587. kMinPackedRStringLength = sizeof(ProtoRString);
  588.  
  589.  
  590. TYPE
  591. RString64 = RECORD
  592.     charSet: CharacterSet;
  593.     dataLength: INTEGER;
  594.  
  595.     body: PACKED ARRAY[1..kRString64Size] OF Byte;
  596.     END;
  597.  
  598. RString32 = RECORD
  599.     charSet: CharacterSet;
  600.     dataLength: INTEGER;
  601.  
  602.     body: PACKED ARRAY[1..kRString32Size] OF Byte;
  603.     END;
  604.  
  605. RString32Ptr = ^RString32;
  606.  
  607.  
  608.  
  609. {
  610. Standard definitions for the entity type field and attribute type
  611. have been moved to the end of the file.
  612. }
  613.  
  614.  
  615. {
  616. Copies str1 to str2.  str2Length is the size of str2, excluding header.
  617. A memFull error will be returned if that is not as large as str1->length.
  618. }
  619.  
  620. FUNCTION OCECopyRString(str1: RStringPtr; str2: RStringPtr; str2Length: INTEGER): OSErr;
  621.     INLINE $303C, kOCECopyRString, $AA5C;
  622.  
  623.  
  624. {    Make an RString from a C STRING.  If the c STRING is bigger than rStrLength,
  625. only rStrLength bytes will be copied. (rStrLength does not include the header size) }
  626.  
  627. PROCEDURE OCECToRString(cStr: Ptr; charSet: CharacterSet; rStr: RStringPtr;
  628.         rStrLength: INTEGER);
  629.     INLINE $303C, kOCECToRString, $AA5C;
  630.  
  631.  
  632. {    Make an RString from a Pascal STRING.  If the Pascal STRING is bigger than rStrLength,
  633. only rStrLength bytes will be copied. (rStrLength does not include the header size) }
  634.  
  635. PROCEDURE OCEPToRString(pStr: Str255; charSet: CharacterSet; rStr: RStringPtr;
  636.         rStrLength: INTEGER);
  637.     INLINE $303C, kOCEPToRString, $AA5C;
  638.  
  639.  
  640. {    Make a Pascal STRING from an RString.  It's up to you to check the CHAR set of
  641. the RString, or if the length of the RString is greater than 255 (the Pascal STRING's
  642. length will simply be the lower byte of the RString's length).  The StringPtr that is
  643. returned will point directly into the RString (no memory will be allocated). }
  644.  
  645. FUNCTION OCERToPString(rStr: RStringPtr): StringPtr; INLINE $303C, kOCERToPString, $AA5C;
  646.  
  647.  
  648. {    Check the relative equality of two RStrings.  Determines if str1 is greater than,
  649. equal to, or less than str2.  Result types for OCERelRString are defined in <OSUtils.h>
  650. (same as for RelString). }
  651.  
  652. FUNCTION OCERelRString(str1: UNIV Ptr; str2: UNIV Ptr; kind: RStringKind): INTEGER;
  653.     INLINE $303C, kOCERelRString, $AA5C;
  654.  
  655.  
  656. {    Check for equality of two RStrings. Returns true if equal. }
  657.  
  658. FUNCTION OCEEqualRString(str1: UNIV Ptr; str2: UNIV Ptr; kind: RStringKind): BOOLEAN;
  659.     INLINE $303C, kOCEEqualRString, $AA5C;
  660.  
  661.  
  662. {    Check the validity of an RString.  Returns true if the RString is valid }
  663.  
  664. FUNCTION OCEValidRString(str: UNIV Ptr; kind: RStringKind): BOOLEAN;
  665.     INLINE $303C, kOCEValidRString, $AA5C;
  666.  
  667.  
  668.  
  669.  
  670. {*** CreationID ***}
  671.  
  672. TYPE
  673. CreationID = RECORD
  674.     source: LONGINT;                    { Fields definitions and usage are not defined }
  675.     seq: LONGINT;
  676.     END;
  677.  
  678. AttributeCreationID = CreationID;
  679. CreationIDPtr = ^CreationID;
  680.  
  681.  
  682.  
  683.  
  684. { Returns a pointer to a null CreationID . }
  685.  
  686. FUNCTION OCENullCID: CreationIDPtr;
  687.     INLINE $303C, kOCENullCID, $AA5C;
  688.  
  689.  
  690. { Returns a pointer to a special CreationID used within the PathFinder. }
  691.  
  692. FUNCTION OCEPathFinderCID: CreationIDPtr;
  693.     INLINE $303C, kOCEPathFinderCID, $AA5C;
  694.  
  695.  
  696. { Sets the CreationID to a null value. }
  697.  
  698. PROCEDURE OCESetCreationIDtoNull(VAR cid: CreationID);
  699.     INLINE $303C, kOCESetCreationIDtoNull, $AA5C;
  700.  
  701.  
  702. { Copies the value of cid1 to cid2. }
  703.  
  704. PROCEDURE OCECopyCreationID(cid1: CreationID; VAR cid2: CreationID);
  705.     INLINE $303C, kOCECopyCreationID, $AA5C;
  706.  
  707.  
  708. { Check the equality of two CreationIDs. }
  709.  
  710. FUNCTION OCEEqualCreationID(cid1: CreationID; cid2: CreationID): BOOLEAN;
  711.     INLINE $303C, kOCEEqualCreationID, $AA5C;
  712.  
  713.  
  714.  
  715.  
  716. {*** NetworkSpec ***}
  717.  
  718. {
  719. For the record, a NetworkSpec is an RString with a smaller maximum size.
  720. I don't justtypedef it to an RString, because I want the definition of the NetworkSpec
  721. struct to contain the max length.  But it should be possible to typecast any
  722. NetworkSpec to an RString and use all the RString utilities on it.
  723. }
  724.  
  725. TYPE
  726. NetworkSpec = RECORD
  727.     charSet: CharacterSet;
  728.     dataLength: INTEGER;
  729.  
  730.     body: PACKED ARRAY[1..kNetworkSpecMaxBytes] OF Byte;    { always fixed at the max size }
  731.     END;
  732.  
  733. NetworkSpecPtr = ^NetworkSpec;
  734.  
  735.  
  736.  
  737. {*** PackedPathName ***}
  738.  
  739. {
  740. struct PackedPathName is a maximum-sized structure.  Allocate one of
  741. these and it will hold any valid packed pathname.
  742. }
  743.  
  744. PackedPathNameHeader = RECORD
  745.     dataLength: INTEGER;                        { length excludes the space for the length field }
  746.     END;
  747.  
  748. CONST
  749. kPathNameMaxBytesMinusSizeofInteger = kPathNameMaxBytes - sizeof(INTEGER);
  750.  
  751. TYPE
  752. PackedPathName = RECORD
  753.     dataLength: INTEGER;
  754.     
  755.     data: PACKED ARRAY[1..kPathNameMaxBytesMinusSizeofInteger] OF Byte;
  756.     END;
  757.  
  758.  
  759. {
  760. struct ProtoPackedPathName is a minimum-sized structure.  Use this
  761. for a variable-length packed PathName.
  762. }
  763.  
  764. ProtoPackedPathName = RECORD
  765.     dataLength: INTEGER;
  766.     
  767.     { Followed by data }
  768.     END;
  769.  
  770. PackedPathNamePtr = ^PackedPathName;
  771. ProtoPackedPathNamePtr = ^ProtoPackedPathName;
  772.  
  773.  
  774.  
  775.  
  776. {
  777. Copy the contents of path1 to path2.  path2Length is the size of path2, and must
  778. be large enough to hold a copy of path1.  A memFull error will be returned if that
  779. is not the case.
  780. }
  781.  
  782. FUNCTION OCECopyPackedPathName(path1: PackedPathNamePtr; path2: PackedPathNamePtr;
  783.         path2Length: INTEGER): OSErr;
  784.     INLINE $303C, kOCECopyPackedPathName, $AA5C;
  785.  
  786.  
  787. {
  788. Returns true if packed path pointer is nil, or is of zero length, or is of
  789. length 2 and nParts of zero.
  790. }
  791.  
  792. FUNCTION OCEIsNullPackedPathName(path: PackedPathNamePtr): BOOLEAN;
  793.     INLINE $303C, kOCEIsNullPackedPathName, $AA5C;
  794.  
  795.  
  796. {
  797. OCEUnpackPathName breaks apart the path into its component RStrings, writing STRING
  798. pointers into the array 'parts', which the client asserts can hold as many as
  799. 'nParts' elements. The number of parts actually found is returned.  STRINGs are
  800. placed in the array in order from lowest to highest.  The first pathName element
  801. beneath the root appears last.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO
  802. THE PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  803. WITH THE UNPACKED STRUCT AS WELL
  804. }
  805.  
  806. FUNCTION OCEUnpackPathName(path: PackedPathNamePtr; VAR parts: RStringPtr;
  807.         nParts: INTEGER): INTEGER;
  808.     INLINE $303C, kOCEUnpackPathName, $AA5C;
  809.  
  810.  
  811. {
  812. OCEPackedPathNameSize computes the number of bytes of memory needed to hold a
  813. PackedPathName manufactured from the array of parts.  This length
  814. includes the length of the length field of PackedPathName, so it
  815. is safe to do a NewPtr (OCEPackedPathNameSize(...)).
  816. }
  817.  
  818. FUNCTION OCEPackedPathNameSize(VAR parts: RStringPtr; nParts: INTEGER): INTEGER;
  819.     INLINE $303C, kOCEPackedPathNameSize, $AA5C;
  820.  
  821.  
  822. { OCEDNodeNameCount returns the number of RStrings contained within the path. }
  823.  
  824. FUNCTION OCEDNodeNameCount(path: PackedPathNamePtr): INTEGER;
  825.     INLINE $303C, kOCEDNodeNameCount, $AA5C;
  826.  
  827.  
  828. {
  829. OCEPackPathName packs the parts into the storage provided as 'path'.  path must be
  830. large enough to hold the packed pathname.  A memFull error will be returned if
  831. pathLength is too small.  parts[0] should contain the deepest pathName element,
  832. and parts[nParts - 1] should contain the name of the first pathName element beneath
  833. the root.
  834. }
  835.  
  836. FUNCTION OCEPackPathName(VAR parts: RStringPtr; nParts: INTEGER;
  837.         path: PackedPathNamePtr; pathLength: INTEGER): OSErr;
  838.     INLINE $303C, kOCEPackPathName, $AA5C;
  839.  
  840.  
  841. {
  842. Check the equality of two packed paths.
  843. }
  844.  
  845. FUNCTION OCEEqualPackedPathName(path1: PackedPathNamePtr;
  846.                     path2: PackedPathNamePtr): BOOLEAN;
  847.     INLINE $303C, kOCEEqualPackedPathName, $AA5C;
  848.  
  849.  
  850. {
  851. OCEValidPackedPathName checks that the packed PathName is internally consistent.
  852. Returns true if it's ok.
  853. }
  854.  
  855. FUNCTION OCEValidPackedPathName(path: PackedPathNamePtr): BOOLEAN;
  856.     INLINE $303C, kOCEValidPackedPathName, $AA5C;
  857.  
  858.  
  859.  
  860.  
  861. {*** DirDiscriminator ***}
  862.  
  863. TYPE
  864. DirDiscriminator = RECORD
  865.     signature: OCEDirectoryKind;
  866.     misc: LONGINT;
  867.     END;
  868.  
  869.  
  870.  
  871.  
  872. { Copies the value of disc1 to disc2. }
  873.  
  874. PROCEDURE OCECopyDirDiscriminator(disc1: DirDiscriminator;
  875.         VAR disc2: DirDiscriminator);
  876.     INLINE $303C, kOCECopyDirDiscriminator, $AA5C;
  877.  
  878.  
  879. { Check the equality of two DirDiscriminators. }
  880.  
  881. FUNCTION OCEEqualDirDiscriminator(disc1: DirDiscriminator;
  882.         disc2: DirDiscriminator): BOOLEAN;
  883.     INLINE $303C, kOCEEqualDirDiscriminator, $AA5C;
  884.  
  885.  
  886.  
  887. {********************************************************************************
  888.  
  889. This structure is called RLI because it really contains all the info you
  890. need to locate a record within the entire name space.  It contains four fields.
  891. The first two are the name of the directory and a directory discriminator.  These
  892. two fields are used to indicate to which directory a given record belongs.  The
  893. discriminator is used to distinguish between two different directories that have
  894. the same name.
  895.  
  896. The other two fields in the RLI structure are used to indicate a particular
  897. directory node within the directory specified by the directoryName and
  898. discriminator fields.  These fields are exactly analagous to the dirID and
  899. pathname used in HFS.  It is possible to specify a dNode just by dNodeNumber
  900. (pathname is nil), or just by pathname (dNodeNumber is set to kNULLDNodeNumber),
  901. or by a combination of the two.  The latter is called a 'partial pathname', and
  902. while it is valid in the Directory Manager API, it is not supported by ADAP
  903. directories in Release 1.
  904.  
  905. Note that the path parameter does not include the directory name, but holds
  906. the names of all the nodes on the path to the desired directory node, starting
  907. with the directory node and working its way up the tree.
  908.  
  909.  ********************************************************************************}
  910.  
  911.  
  912. {*** RLI ***}
  913.  
  914.  
  915. TYPE
  916. DirectoryName = RECORD
  917.     charSet: CharacterSet;
  918.     dataLength: INTEGER;
  919.  
  920.     body: PACKED ARRAY[1..kDirectoryNameMaxBytes] OF Byte;    { space for directory name }
  921.     END;
  922.  
  923. DirectoryNamePtr = ^DirectoryName;
  924.  
  925.  
  926. DNodeNum = LONGINT;                        { Directory node number }
  927.  
  928. RLI = RECORD                            { Record Location Info structure: }
  929.     directoryName: DirectoryNamePtr;    { pointer to the name of the directory root }
  930.     discriminator: DirDiscriminator;    { used to discriminate between dup dir names }
  931.     dNodeNumber: DNodeNum;                { number of the node }
  932.     path: PackedPathNamePtr;            { old-style RLI }
  933.     END;
  934.  
  935. RLIPtr = ^RLI;
  936.  
  937.  
  938.  
  939.  
  940.  
  941. {
  942. Create a new RLI from the directory name, discriminator, DNode number, and
  943. PackedPathName.  You must allocate the storage for the RLI and pass in a pointer
  944. to it.
  945. }
  946.  
  947. PROCEDURE OCENewRLI(VAR newRLI: RLI; dirName: DirectoryNamePtr;
  948.         VAR discriminator: DirDiscriminator; dNodeNumber: DNodeNum;
  949.         path: PackedPathNamePtr);
  950.     INLINE $303C, kOCENewRLI, $AA5C;
  951.  
  952.  
  953. {
  954. Duplicate the contents of rli1 to rli2.  No errors are returned. This
  955. simply copies the pointers to the directory name and path, wiping out any pointer
  956. that you might have had in there.
  957. }
  958.  
  959. PROCEDURE OCEDuplicateRLI(rli1: RLI; VAR rli2: RLI);
  960.     INLINE $303C, kOCEDuplicateRLI, $AA5C;
  961.  
  962.  
  963. {
  964. Copy the contents of rli1 to rli2.  rli2 must already contain
  965. pointers to structures large enough to hold copies of the corresponding
  966. fields from rli1.  A memFull error will be returned if that is not the case.
  967. So if you allocate a brand new empty destination, you must at least set up
  968. its length fields.
  969. }
  970.  
  971. FUNCTION OCECopyRLI(rli1: RLI; VAR rli2: RLI): OSErr;
  972.     INLINE $303C, kOCECopyRLI, $AA5C;
  973.  
  974.  
  975. {
  976. Check the equality of two RLIs.  This will take into account differences
  977. in the case and diacriticals of the directoryName and the PathName.
  978. NOTE THAT THIS WILL FAIL IF rli1 CONTAINS A DNODENUMBER AND A NIL PATHNAME,
  979. AND rli2 CONTAINS kNULLDNodeNumber AND A NON-NIL PATHNAME.  IN OTHER WORDS,
  980. THE TWO rlis MUST BE OF THE SAME FORM TO CHECK FOR EQUALITY.
  981. The one exception is that if the pathname is nil, a dNodeNumber of zero and
  982. kRootDNodeNumber will be treated as equal.
  983. }
  984.  
  985. FUNCTION OCEEqualRLI(rli1: RLI; rli2: RLI): BOOLEAN;
  986.     INLINE $303C, kOCEEqualRLI, $AA5C;
  987.  
  988.  
  989. {
  990. Check the validity of an RLI.  This checks that the directory name length
  991. is within bounds, and the packed pathname (specified: if) is valid.
  992. }
  993.  
  994. FUNCTION OCEValidRLI(theRLI: RLI): BOOLEAN;
  995.     INLINE $303C, kOCEValidRLI, $AA5C;
  996.  
  997.  
  998.  
  999.  
  1000. {*** PackedRLI ***}
  1001.  
  1002. {
  1003. struct PackedRLI is a maximum-sized structure.  Allocate one of
  1004. these and it will hold any valid packed pathname.
  1005. }
  1006.  
  1007. CONST
  1008. kRLIMaxBytes = (sizeof (RString) + sizeof (DirDiscriminator) +
  1009.             sizeof (DNodeNum) + kPathNameMaxBytes);
  1010.  
  1011. TYPE
  1012. PackedRLIHeader = RECORD
  1013.     dataLength: INTEGER;                { length excludes the space for the length field }
  1014.     END;
  1015.  
  1016. PackedRLI = RECORD
  1017.     dataLength: INTEGER;
  1018.     
  1019.     data: PACKED ARRAY[1..kRLIMaxBytes] OF Byte;
  1020.     END;
  1021.  
  1022.  
  1023. {
  1024. struct ProtoPackedRLI is a minimum-sized structure.  Use this
  1025. for a variable-length packed RLI.
  1026. }
  1027.  
  1028. ProtoPackedRLI = RECORD
  1029.     dataLength: INTEGER;
  1030.     
  1031.     { Followed by data }
  1032.     END;
  1033.  
  1034.  
  1035. PackedRLIPtr = ^PackedRLI;
  1036. ProtoPackedRLIPtr = ^ProtoPackedRLI;
  1037.  
  1038. CONST
  1039. kMinPackedRLISize  = (sizeof (ProtoPackedRLI) +
  1040.             sizeof (DirDiscriminator) + sizeof (DNodeNum) +
  1041.             kMinPackedRStringLength + sizeof (ProtoPackedPathName));
  1042.  
  1043.  
  1044.  
  1045.  
  1046. {
  1047. Copy the contents of prli1 to prli2.  prli2Length is the size of prli2, and must
  1048. be large enough to hold a copy of prli1.  A memFull error will be returned if that
  1049. is not the case.
  1050. }
  1051.  
  1052. FUNCTION OCECopyPackedRLI(prli1: PackedRLIPtr; prli2: PackedRLIPtr;
  1053.             prli2Length: INTEGER): OSErr;
  1054.     INLINE $303C, kOCECopyPackedRLI, $AA5C;
  1055.  
  1056.  
  1057. {
  1058. OCEUnpackRLI breaks apart the prli into its components, writing pointers into
  1059. the rli structure.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE
  1060. PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  1061. WITH THE UNPACKED STRUCT AS WELL
  1062. }
  1063.  
  1064. PROCEDURE OCEUnpackRLI(prli: PackedRLIPtr; VAR theRLI: RLI);
  1065.     INLINE $303C, kOCEUnpackRLI, $AA5C;
  1066.  
  1067.  
  1068. {
  1069. OCEPackedRLISize computes the number of bytes of memory needed to hold a
  1070. PackedRLI manufactured from an RLI.  This length
  1071. includes the length of the length field of PackedRLI, so it
  1072. is safe to do a NewPtr (OCEPackedRLISize(...)).
  1073. }
  1074.  
  1075. FUNCTION OCEPackedRLISize(theRLI: RLI): INTEGER;
  1076.     INLINE $303C, kOCEPackedRLISize, $AA5C;
  1077.  
  1078.  
  1079. {
  1080. OCEPackRLI packs the RLI into the storage provided as 'prli'.  prli must be
  1081. large enough to hold the packed RLI.  A memFull error will be returned if
  1082. prliLength is too small.
  1083. }
  1084.  
  1085. FUNCTION OCEPackRLI(theRLI: RLI; prli: PackedRLIPtr; prliLength: INTEGER): OSErr;
  1086.     INLINE $303C, kOCEPackRLI, $AA5C;
  1087.  
  1088.  
  1089. {
  1090. OCEPackedRLIPartsSize computes the number of bytes of memory needed to hold a
  1091. PackedRLI manufactured from the parts of an RLI.  This length
  1092. includes the length of the length field of PackedRLI, so it
  1093. is safe to do a NewPtr (OCEPackedRLIPartsSize(...)).
  1094. }
  1095.  
  1096. FUNCTION OCEPackedRLIPartsSize(dirName: DirectoryNamePtr;
  1097.             VAR parts: RStringPtr; nParts: INTEGER): INTEGER;
  1098.     INLINE $303C, kOCEPackedRLIPartsSize, $AA5C;
  1099.  
  1100.  
  1101. {
  1102. OCEPackRLIParts packs the parts of an RLI into the storage provided as 'prli'.
  1103. prli must be large enough to hold the packed RLI.  A memFull error will be returned
  1104. if prliLength is too small.
  1105. }
  1106.  
  1107. FUNCTION OCEPackRLIParts(dirName: DirectoryNamePtr;
  1108.             discriminator: DirDiscriminator; dNodeNumber: DNodeNum;
  1109.             VAR parts: RStringPtr; nParts: INTEGER; prli: PackedRLIPtr;
  1110.             prliLength: INTEGER): OSErr;
  1111.     INLINE $303C, kOCEPackRLIParts, $AA5C;
  1112.  
  1113.  
  1114. {
  1115. Check the equality of two packed prlis.
  1116. }
  1117.  
  1118. FUNCTION OCEEqualPackedRLI(prli1: PackedRLIPtr; prli2: PackedRLIPtr): BOOLEAN;
  1119.     INLINE $303C, kOCEEqualPackedRLI, $AA5C;
  1120.  
  1121.  
  1122. {
  1123. Check the validity of a packed RLI.  This checks that the directory name length
  1124. is within bounds, and the packed pathname (specified: if) is valid.
  1125. }
  1126.  
  1127. FUNCTION OCEValidPackedRLI(prli: PackedRLIPtr): BOOLEAN;
  1128.     INLINE $303C, kOCEValidPackedRLI, $AA5C;
  1129.  
  1130.  
  1131. {
  1132. If this packed RLI describes a Personal Directory, this call will return a pointer
  1133. to an alias record that can be used to find the actual file.  Otherwise, it returns nil.
  1134. }
  1135.  
  1136. FUNCTION OCEExtractAlias(prli: PackedRLIPtr): AliasPtr;
  1137.     INLINE $303C, kOCEExtractAlias, $AA5C;
  1138.  
  1139.  
  1140. {
  1141. This call returns a pointer to a packed RLI that represents the "Catalogs" icon, or
  1142. the root of all directories.  It is used in the CollabPack.
  1143. }
  1144.  
  1145. FUNCTION OCEGetDirectoryRootPackedRLI: PackedRLIPtr;
  1146.     INLINE $303C, kOCEGetRootPackedRLI, $AA5C;
  1147.  
  1148.  
  1149.  
  1150.  
  1151.  
  1152. {*** LocalRecordID ***}
  1153.  
  1154. TYPE
  1155. LocalRecordID = RECORD
  1156.     cid: CreationID;
  1157.     recordName: RStringPtr;
  1158.     recordType: RStringPtr;
  1159.     END;
  1160.  
  1161.  
  1162. LocalRecordIDPtr = ^LocalRecordID;
  1163.  
  1164.  
  1165.  
  1166. { Create a LocalRecordID from a name, type, and CreationID }
  1167.  
  1168. PROCEDURE OCENewLocalRecordID(recordName: RStringPtr; recordType: RStringPtr;
  1169.         cid: CreationID; VAR lRID: LocalRecordID);
  1170.     INLINE $303C, kOCENewLocalRecordID, $AA5C;
  1171.  
  1172. {
  1173. Copy LocalRecordID lRID1 to LocalRecordID lRID2.  lRID2 must already contain
  1174. pointers to RString structures large enough to hold copies of the corresponding
  1175. fields from lRID1.  A memFull error will be returned if that is not the case.
  1176. So if you allocate a brand new empty destination, you must at least set up
  1177. its length field.
  1178. }
  1179.  
  1180. FUNCTION OCECopyLocalRecordID(lRID1: LocalRecordID; VAR lRID2: LocalRecordID): OSErr;
  1181.     INLINE $303C, kOCECopyLocalRecordID, $AA5C;
  1182.  
  1183.  
  1184. {
  1185. Check the equality of two local RIDs.
  1186. }
  1187.  
  1188. FUNCTION OCEEqualLocalRecordID(lRID1: LocalRecordID; lRID2: LocalRecordID): BOOLEAN;
  1189.     INLINE $303C, kOCEEqualLocalRecordID, $AA5C;
  1190.  
  1191.  
  1192.  
  1193.  
  1194. {*** ShortRecordID ***}
  1195.  
  1196. TYPE
  1197. ShortRecordID = RECORD
  1198.     rli: PackedRLIPtr;
  1199.     cid: CreationID;
  1200.     END;
  1201.  
  1202. ShortRecordIDPtr = ^ShortRecordID;
  1203.  
  1204.  
  1205.  
  1206. { Create a ShortRecordID from an RLI struct and a CreationID }
  1207.  
  1208. PROCEDURE OCENewShortRecordID(theRLI: PackedRLIPtr; cid: CreationID;
  1209.         sRID: ShortRecordIDPtr);
  1210.     INLINE $303C, kOCENewShortRecordID, $AA5C;
  1211.  
  1212.  
  1213. {
  1214. Copy ShortRecordID sRID1 to ShortRecordID sRID2.  sRID2 must already contain
  1215. pointers to structures large enough to hold copies of the corresponding
  1216. fields from sRID1.  A memFull error will be returned if that is not the case.
  1217. So if you allocate a brand new empty destination, you must at least set up
  1218. its length fields.
  1219. }
  1220.  
  1221. FUNCTION OCECopyShortRecordID(sRID1: ShortRecordID; VAR sRID2: ShortRecordID): OSErr;
  1222.     INLINE $303C, kOCECopyShortRecordID, $AA5C;
  1223.  
  1224.  
  1225. {
  1226. Check the equality of two INTEGER RIDs.
  1227. }
  1228.  
  1229. FUNCTION OCEEqualShortRecordID(sRID1: ShortRecordID; sRID2: ShortRecordID): BOOLEAN;
  1230.     INLINE $303C, kOCEEqualShortRecordID, $AA5C;
  1231.  
  1232.  
  1233.  
  1234.  
  1235. {*** RecordID ***}
  1236.  
  1237. TYPE
  1238. RecordID = RECORD
  1239.     rli: PackedRLIPtr;    { pointer to a packed rli structure }
  1240.     local: LocalRecordID;
  1241.     END;
  1242.  
  1243. RecordIDPtr = ^RecordID;
  1244.  
  1245.  
  1246.  
  1247. {    Create a RecordID from a packed RLI struct and a LocalRecordID.
  1248. This doesn't allocate any new space; the RecordID points to the same
  1249. packed RLI struct and the same name and type RStrings. }
  1250.  
  1251. PROCEDURE OCENewRecordID(theRLI: PackedRLIPtr; lRID: LocalRecordID;
  1252.             VAR rid: RecordID);
  1253.     INLINE $303C, kOCENewRecordID, $AA5C;
  1254.  
  1255.  
  1256. {
  1257. Copy RecordID RID1 to RecordID RID2.  RID2 must already contain
  1258. pointers to structures large enough to hold copies of the corresponding
  1259. fields from lRID1.  A memFull error will be returned if that is not the case.
  1260. So if you allocate a brand new empty destination, you must at least set up
  1261. its length fields.
  1262. }
  1263.  
  1264. FUNCTION OCECopyRecordID(rid1: RecordID; rid2: RecordID): OSErr;
  1265.     INLINE $303C, kOCECopyRecordID, $AA5C;
  1266.  
  1267.  
  1268. {    Check the equality of two RIDs. }
  1269.  
  1270. FUNCTION OCEEqualRecordID(rid1: RecordID; rid2: RecordID): BOOLEAN;
  1271.     INLINE $303C, kOCEEqualRecordID, $AA5C;
  1272.  
  1273.  
  1274.  
  1275.  
  1276.  
  1277. {*** PackedRecordID ***}
  1278.  
  1279. {
  1280. struct PackedRecordID is a maximum-sized structure.  Allocate one of
  1281. these and it will hold any valid packed RecordID.
  1282. }
  1283.  
  1284. CONST
  1285. kPackedRecordIDMaxBytes = kPathNameMaxBytes + sizeof(DNodeNum) +
  1286.             sizeof(DirDiscriminator) + sizeof(CreationID) + (3*sizeof(RString));
  1287.  
  1288. TYPE
  1289. PackedRecordIDHeader = RECORD
  1290.     dataLength: INTEGER;                    { length excludes the space for the length field }
  1291.     END;
  1292.     
  1293. PackedRecordID = RECORD
  1294.     dataLength: INTEGER;
  1295.     
  1296.     data: PACKED ARRAY[1..kPackedRecordIDMaxBytes] OF Byte;
  1297.     END;
  1298.  
  1299.  
  1300. {
  1301. struct ProtoPackedRecordID is a minimum-sized structure.  Use this
  1302. for a variable-length packed RecordID.
  1303. }
  1304.  
  1305. ProtoPackedRecordID = RECORD
  1306.     dataLength: INTEGER;
  1307.     
  1308.     { Followed by data }
  1309.     END;
  1310.  
  1311. PackedRecordIDPtr = ^PackedRecordID;
  1312. ProtoPackedRecordIDPtr = ^ProtoPackedRecordID;
  1313.  
  1314.  
  1315.  
  1316. {
  1317. Copy PackedRecordID pRID1 to PackedRecordID pRID2.  pRID2 must already contain
  1318. pointers to structures large enough to hold copies of the corresponding
  1319. fields from pRID1.  A memFull error will be returned if that is not the case.
  1320. pRID2Length is the number of bytes that can be put into pRID2, not counting the
  1321. packed RecordID header.
  1322. }
  1323.  
  1324. FUNCTION OCECopyPackedRecordID(pRID1: PackedRecordIDPtr; pRID2: PackedRecordIDPtr;
  1325.         pRID2Length: INTEGER): OSErr;
  1326.     INLINE $303C, kOCECopyPackedRecordID, $AA5C;
  1327.  
  1328.  
  1329. {
  1330. Create a RecordID from a PackedRecordID.
  1331. NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1332. OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL
  1333. }
  1334.  
  1335. PROCEDURE OCEUnpackRecordID(pRID: PackedRecordIDPtr; VAR rid: RecordID);
  1336.     INLINE $303C, kOCEUnpackRecordID, $AA5C;
  1337.  
  1338.  
  1339. {
  1340. Create a PackedRecordID from a RecordID.  pRID must be large enough to contain
  1341. the packed RecordID.  A memFull error will be returned if that is not the case.
  1342. packedRecordIDLength is the number of bytes that can be put into pRID, not
  1343. counting the header.
  1344. }
  1345.  
  1346. FUNCTION OCEPackRecordID(rid: RecordID; pRID: PackedRecordIDPtr;
  1347.         packedRecordIDLength: INTEGER): OSErr;
  1348.     INLINE $303C, kOCEPackRecordID, $AA5C;
  1349.  
  1350.  
  1351. {
  1352. Compute the number of bytes of memory needed to hold a RecordID when packed. This
  1353. length includes the length of the length field of PackedRecordID, so it
  1354. is safe to do a NewPtr (OCEPackedRecordIDSize(...)).
  1355. }
  1356.  
  1357. FUNCTION OCEPackedRecordIDSize(rid: RecordID): INTEGER;
  1358.     INLINE $303C, kOCEPackedRecordIDSize, $AA5C;
  1359.  
  1360.  
  1361. {
  1362. Check the equality of two packed RIDs.
  1363. }
  1364.  
  1365. FUNCTION OCEEqualPackedRecordID(pRID1: PackedRecordIDPtr; pRID2: PackedRecordIDPtr): BOOLEAN;
  1366.     INLINE $303C, kOCEEqualPackedRecordID, $AA5C;
  1367.  
  1368.  
  1369. { OCEValidPackedRecordID checks the validity of a packed record ID. }
  1370.  
  1371. FUNCTION OCEValidPackedRecordID(pRID: PackedRecordIDPtr): BOOLEAN;
  1372.     INLINE $303C, kOCEValidPackedRecordID, $AA5C;
  1373.  
  1374.  
  1375.  
  1376.  
  1377.  
  1378. {*** DSSpec ***}
  1379.  
  1380. TYPE
  1381. DSSpec = RECORD
  1382.     entitySpecifier: ^RecordID;
  1383.     extensionType: OSType;
  1384.     extensionSize: INTEGER;
  1385.     extensionValue: Ptr;
  1386.     END;
  1387.  
  1388. DSSpecPtr = ^DSSpec;
  1389.  
  1390. {
  1391. struct PackedDSSpec is NOT a maximum-sized structure.  Allocate one of
  1392. these and it will hold any valid packed RecordID, but not necessarily any additional
  1393. data.
  1394. }
  1395.  
  1396. CONST
  1397. kPackedDSSpecMaxBytes    = (sizeof (PackedRecordID) + sizeof (OSType) + sizeof (INTEGER));
  1398.  
  1399. TYPE
  1400. PackedDSSpecHeader = RECORD
  1401.     dataLength: INTEGER;            { length excludes the space for the length field }
  1402.     END;
  1403.         
  1404. PackedDSSpec = RECORD
  1405.     dataLength: INTEGER;
  1406.     
  1407.     data: PACKED ARRAY[1..kPackedDSSpecMaxBytes] OF Byte;
  1408.     END;
  1409.  
  1410.  
  1411. {
  1412. struct ProtoPackedDSSpec is a minimum-sized structure.  Use this
  1413. for a variable-length packed DSSpec.
  1414. }
  1415.  
  1416. ProtoPackedDSSpec = RECORD
  1417.     dataLength: INTEGER;
  1418.     
  1419.     { Followed by data }
  1420.     END;
  1421.  
  1422. PackedDSSpecPtr = ^PackedDSSpec;
  1423. ProtoPackedDSSpecPtr = ^ProtoPackedDSSpec;
  1424.  
  1425.  
  1426.  
  1427. {
  1428. Copy PackedDSSpec pdss1 to PackedDSSpec pdss2.  pdss2 must already contain
  1429. pointers to structures large enough to hold copies of the corresponding
  1430. fields from pdss1.  A memFull error will be returned if that is not the case.
  1431. pdss2Length is the number of bytes that can be put into pdss2, not counting the
  1432. packed DSSpec header.
  1433. }
  1434.  
  1435. FUNCTION OCECopyPackedDSSpec(pdss1: PackedDSSpecPtr;
  1436.             pdss2: PackedDSSpecPtr; pdss2Length: INTEGER): OSErr;
  1437.     INLINE $303C, kOCECopyPackedDSSpec, $AA5C;
  1438.  
  1439.  
  1440. {
  1441. Create a DSSpec from a PackedDSSpec.
  1442. NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1443. OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL.
  1444. A pointer to the extension is returned in dss->extensionValue, and the length of that
  1445. extension is returned in dss->extensionSize.  If there is no extension, dss->extensionValue will
  1446. be set to nil.  This routine will unpack the RecordID (any: if) into rid, unpack the rest
  1447. into dss, and set dss->entitySpecifier to rid.
  1448. }
  1449.  
  1450. PROCEDURE OCEUnpackDSSpec(pdss: PackedDSSpecPtr; VAR dss: DSSpec;
  1451.             VAR rid: RecordID); INLINE $303C, kOCEUnpackDSSpec, $AA5C;
  1452.  
  1453.  
  1454. {
  1455. Create a PackedDSSpec from a DSSpec.  pdss must be large enough to
  1456. contain the packed RecordID and any extension.  A memFull error will be returned if that
  1457. is not the case.  pdssLength is the number of bytes that can be put into pdss,
  1458. not counting the header.
  1459. }
  1460.  
  1461. FUNCTION OCEPackDSSpec(dss: DSSpec; pdss: PackedDSSpecPtr;
  1462.         pdssLength: INTEGER): OSErr;
  1463.     INLINE $303C, kOCEPackDSSpec, $AA5C;
  1464.  
  1465.  
  1466. {
  1467. Compute the number of bytes of memory needed to hold a DSSpec when packed. This
  1468. length includes the length of the length field of PackedDSSpec, so it
  1469. is safe to do a NewPtr (OCEPackedDSSpecSize(...)).
  1470. }
  1471.  
  1472. FUNCTION OCEPackedDSSpecSize(dss: DSSpec): INTEGER;
  1473.     INLINE $303C, kOCEPackedDSSpecSize, $AA5C;
  1474.  
  1475.  
  1476. {    Check the equality of two DSSpecs.  This compares all fields, even the
  1477. extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1478. diacrit-insensitive manner. }
  1479.  
  1480. FUNCTION OCEEqualDSSpec(pdss1: DSSpec; pdss2: DSSpec): BOOLEAN;
  1481.     INLINE $303C, kOCEEqualDSSpec, $AA5C;
  1482.  
  1483.  
  1484. {    Check the equality of two PackedDSSpecs.  This compares all fields, even the
  1485. extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1486. diacrit-insensitive manner. }
  1487.  
  1488. FUNCTION OCEEqualPackedDSSpec(pdss1: PackedDSSpecPtr;
  1489.         pdss2: PackedDSSpecPtr): BOOLEAN;
  1490.     INLINE $303C, kOCEEqualPackedDSSpec, $AA5C;
  1491.  
  1492.  
  1493. {
  1494. Check the validity of a PackedDSSpec.  If extensionType is
  1495. 'entn', pdss must contain a valid entitySpecifier.  For all other extensionTypes, a nil
  1496. entitySpecifier is valid, but if non-nil, it will be checked for validity.  No check
  1497. is made on the extension.
  1498. }
  1499.  
  1500. FUNCTION OCEValidPackedDSSpec(pdss: PackedDSSpecPtr): BOOLEAN;
  1501.     INLINE $303C, kOCEValidPackedDSSpec, $AA5C;
  1502.  
  1503.  
  1504. {
  1505. Return info about a DSSpec.  This routine does not check validity.  If the
  1506. DSSpec has no extension, we determine whether it represents the root of all
  1507. directories, a single directory, a DNode, or a Record.  Else it is invalid.
  1508. If the DSSpec has an extension, we simply return the extension type.
  1509. }
  1510.  
  1511. FUNCTION OCEGetDSSpecInfo(spec: DSSpec): OSType;
  1512.     INLINE $303C, kOCEGetDSSpecInfo, $AA5C;
  1513.  
  1514.  
  1515. { OCEGetExtensionType returns the extensionType imbedded in the PackedDSSpec. }
  1516.  
  1517. FUNCTION OCEGetExtensionType(pdss: PackedDSSpecPtr): OSType;
  1518.     INLINE $303C, kOCEGetXtnType, $AA5C;
  1519.  
  1520.  
  1521. {
  1522. OCEStreamPackedDSSpec streams (flattens) a directory object a little at a time by
  1523. calling the DSSpecStreamer routine that you provide.
  1524. }
  1525.  
  1526. TYPE
  1527. DSSpecStreamer = ProcPtr;
  1528.     { FUNCTION DSSpecStreamer(VAR buffer: void; count: LONGINT; eof: BOOLEAN;
  1529.         userData: LONGINT): OSErr;}
  1530.  
  1531. FUNCTION OCEStreamPackedDSSpec(dss: DSSpec; stream: DSSpecStreamer;
  1532.         userData: LONGINT; VAR actualCount: LONGINT): OSErr;
  1533.     INLINE $303C, kOCEStreamPackedDSSpec, $AA5C;
  1534.  
  1535.  
  1536.  
  1537.  
  1538.  
  1539. {*** AttributeType ***}
  1540.  
  1541. {
  1542. For the record, an AttributeType is an RString with a smaller maximum size.
  1543. I don't justtypedef it to an RString, because I want the definition of the AttributeType
  1544. struct to contain the max length, because I need to include it in the Attribute struct
  1545. below.  But it should be possible to typecast any AttributeType to an RString and use
  1546. all the RString utilities on it.
  1547. }
  1548.  
  1549. TYPE
  1550. AttributeType = RECORD
  1551.     charSet: CharacterSet;
  1552.     dataLength: INTEGER;
  1553.  
  1554.     body: PACKED ARRAY[1..kAttributeTypeMaxBytes] OF Byte;
  1555.                                         { always fixed at the max size }
  1556.     END;
  1557.  
  1558. AttributeTypePtr = ^AttributeType;
  1559.  
  1560.  
  1561.  
  1562. {*** AttributeValue ***}
  1563.  
  1564. AttributeTag = DescType;            { same class as is used in AppleEvents }
  1565.  
  1566. AttributeValue = RECORD
  1567.     tag: AttributeTag;
  1568.     dataLength: LONGINT;
  1569.     bytes: Ptr;
  1570.     END;
  1571.  
  1572. AttributeValuePtr = ^AttributeValue;
  1573.  
  1574.  
  1575. {*** Attribute ***}
  1576.  
  1577. Attribute = RECORD
  1578.     attributeType: AttributeType;
  1579.     cid: AttributeCreationID;
  1580.     value: AttributeValue;
  1581.     END;
  1582.  
  1583. AttributePtr = ^Attribute;
  1584.  
  1585.  
  1586.  
  1587. FUNCTION OCEGetIndRecordType(STRINGIndex: OCERecordTypeIndex): RStringPtr;
  1588.     INLINE $303C, kOCEGetIndRecordType, $AA5C;
  1589.  
  1590. FUNCTION OCEGetIndAttributeType(STRINGIndex: OCEAttributeTypeIndex): AttributeTypePtr;
  1591.     INLINE $303C, kOCEGetIndAttributeType, $AA5C;
  1592.  
  1593.  
  1594. CONST
  1595. _oceTBDispatch            = $AA5E;
  1596.  
  1597.  
  1598.  
  1599.  
  1600. {$ENDC}    { UsingOCE }
  1601.  
  1602. {$IFC NOT UsingIncludes}
  1603.     END.
  1604. {$ENDC}
  1605.